home *** CD-ROM | disk | FTP | other *** search
/ Aminet 28 / Aminet 28 (1998)(GTI - Schatztruhe)[!][Dec 1998].iso / Aminet / dev / c / qtools0.2-src.lha / src / libqtools / raw.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-07-15  |  10.5 KB  |  463 lines
  1. #define    LIBQTOOLS_CORE
  2. #include "../include/libqtools.h"
  3.  
  4. /*
  5.  * pmalloc/pfree
  6.  */
  7.  
  8. struct palpic *pmalloc(register short int width, register short int height, register struct rgb *palette, register char *picName)
  9. {
  10.   struct palpic *Picture = 0;
  11.  
  12.   if ((Picture = (struct palpic *)tmalloc((width * height) + sizeof(struct palpic)))) {
  13.     Picture->width = width;
  14.     Picture->height = height;
  15.     if (!palette)
  16.       palette = GetPalette();
  17.     Picture->palette = palette;
  18.     if (!picName)
  19.       picName = "nameLess";
  20.     Picture->name = smalloc(picName);
  21.   }
  22.   else
  23.     eprintf(failed_memory, (width * height) + sizeof(struct palpic), "palpicture");
  24.  
  25.   return Picture;
  26. }
  27.  
  28. bool pfree(register struct palpic * Picture)
  29. {
  30.   if (Picture) {
  31.     if (Picture->palette)
  32.       tfree(Picture->palette);
  33.     if (Picture->name)
  34.       tfree(Picture->name);
  35.     tfree(Picture);
  36.     return TRUE;
  37.   }
  38.   else
  39.     return FALSE;
  40. }
  41.  
  42. struct rawdata *rmalloc(register int size, register char *rawName)
  43. {
  44.   struct rawdata *rawData = 0;
  45.  
  46.   if ((rawData = (struct rawdata *)tmalloc(size + sizeof(struct rawdata)))) {
  47.     rawData->size = size;
  48.     if (!rawName)
  49.       rawName = "nameLess";
  50.     rawData->name = smalloc(rawName);
  51.   }
  52.   else
  53.     eprintf(failed_memory, size + sizeof(struct rawdata), "raw data");
  54.  
  55.   return rawData;
  56. }
  57.  
  58. void rfree(register struct rawdata *rawData)
  59. {
  60.   if (rawData) {
  61.     if (rawData->name)
  62.       tfree(rawData->name);
  63.     tfree(rawData);
  64.   }
  65. }
  66.  
  67. /*
  68.  * palette
  69.  */
  70.  
  71. HANDLE palFile = 0, colrFile = 0, transFile = 0;
  72. short int darkness = 0, transparency = -1;
  73. struct rgb *cachedPalette = 0;
  74. unsigned char *cachedColormap = 0;
  75. unsigned char *cachedTransparency = 0;
  76.  
  77. unsigned char *GetTransparency(int transVal)
  78. {
  79.   char transTemplate[NAMELEN_PATH + 1] = "TArray.%2d";
  80.   char transName[NAMELEN_PATH + 1] = "TArray.??";
  81.   unsigned char *NewTransparency;
  82.  
  83.   if ((NewTransparency = (unsigned char *)tmalloc(256 * 256 * sizeof(unsigned char)))) {
  84.     if (!cachedTransparency || (transVal != transparency)) {
  85.       sprintf(transName, transTemplate, transVal);
  86.       if ((transFile = __open(transName, H_READ_BINARY)) < 0) {
  87.     char *transBase;
  88.  
  89.     if ((transBase = getenv("QUAKE_TRANSPARENCY"))) {
  90.       __strncpy(transName, transBase, NAMELEN_PATH);
  91.       __strncat(transName, transTemplate, NAMELEN_PATH);
  92.       __strcpy(transTemplate, transName);
  93.       sprintf(transName, transTemplate, transVal);
  94.       transFile = __open(transName, H_READ_BINARY);
  95.     }
  96.       }
  97.  
  98.       if (transFile < 0) {
  99.     int i, j;
  100.     struct rgb *actPel;
  101.  
  102.     mprintf("build transparency for density %2d\n", transVal);
  103.  
  104.     for (i = 0; i < 256; i++) {
  105.       actPel = &cachedPalette[i];
  106.       for (j = 0; j < 256; j++) {
  107.         int R, G, B;
  108.         struct rgb matchPel;
  109.  
  110.         R = ((((int)(cachedPalette[j].r - actPel->r) * transVal) / 100) + (int)actPel->r);
  111.         G = ((((int)(cachedPalette[j].g - actPel->g) * transVal) / 100) + (int)actPel->g);
  112.         B = ((((int)(cachedPalette[j].b - actPel->b) * transVal) / 100) + (int)actPel->b);
  113.  
  114.         matchPel.r = (unsigned char)R;
  115.         matchPel.g = (unsigned char)G;
  116.         matchPel.b = (unsigned char)B;
  117.         NewTransparency[(i << 8) + j] = Match(&matchPel, cachedPalette);
  118.       }
  119.       mprogress(256, i + 1);
  120.     }
  121.  
  122.     if ((transFile = __open(transName, H_WRITE_BINARY)) > 0)
  123.       __write(transFile, NewTransparency, 256 * 256 * sizeof(unsigned char));
  124.       }
  125.       else
  126.     __read(transFile, NewTransparency, 256 * 256 * sizeof(unsigned char));
  127.  
  128.       if (transFile) {
  129.     __close(transFile);
  130.     transFile = 0;
  131.       }
  132.       if (cachedTransparency)                    /* release wrong cached transval */
  133.     tfree(cachedTransparency);
  134.  
  135.       transparency = transVal;
  136.       cachedTransparency = NewTransparency;
  137.       NewTransparency = GetTransparency(transVal);
  138.     }
  139.     else
  140.       __memcpy(NewTransparency, cachedTransparency, 256 * 256 * sizeof(unsigned char));
  141.   }
  142.   return NewTransparency;
  143. }
  144.  
  145. struct rgb *GetDarkness(struct rgb *Palette)
  146. {
  147.   struct rgb *NewPalette;
  148.  
  149.   if ((NewPalette = (struct rgb *)tmalloc(256 * 3))) {
  150.     short int i;
  151.  
  152.     if (!cachedColormap) {
  153.       bool closecolr = FALSE;
  154.       unsigned char *DarkLevel;
  155.  
  156.       if ((DarkLevel = (unsigned char *)tmalloc(256 * 64))) {
  157.  
  158.     if (!colrFile) {
  159.       if ((colrFile = __open("colormap.lmp", H_READ_BINARY)) < 0) {
  160.         char *colrName;
  161.  
  162.         if ((colrName = getenv("QUAKE_COLORMAP"))) {
  163.           if ((colrFile = __open(colrName, H_READ_BINARY)) < 0)
  164.         eprintf("no colormap available, build new from scratch\n");
  165.           else
  166.         closecolr = TRUE;
  167.         }
  168.         else
  169.           eprintf("no colormap available, build new from scratch\n");
  170.       }
  171.       else
  172.         closecolr = TRUE;
  173.     }
  174.  
  175.     if (colrFile) {
  176.       __read(colrFile, DarkLevel, 256 * 64);
  177.       if (closecolr)
  178.         __close(colrFile);
  179.       else
  180.         __lseek(colrFile, 0, SEEK_SET);
  181.     }
  182.     else {
  183.       /* TODO: how to build colormap */
  184.     }
  185.  
  186.     cachedColormap = DarkLevel;
  187.       }
  188.       else {
  189.     eprintf(failed_memory, 256 * 64, "colormap");
  190.     return Palette;
  191.       }
  192.     }
  193.  
  194.     for (i = 256; i < 256; i++)
  195.       NewPalette[i] = Palette[cachedColormap[i]];
  196.  
  197.     tfree(Palette);
  198.   }
  199.  
  200.   if (NewPalette)
  201.     return NewPalette;
  202.   else
  203.     return Palette;
  204. }
  205.  
  206. struct rgb *GetPalette(void)
  207. {
  208.   struct rgb *Palette;
  209.  
  210.   if ((Palette = (struct rgb *)tmalloc(256 * 3))) {
  211.     if (!cachedPalette) {
  212.       bool closepal = FALSE;
  213.  
  214.       if (!palFile) {
  215.     if ((palFile = __open("palette.lmp", H_READ_BINARY)) < 0) {
  216.       char *palName;
  217.  
  218.       if ((palName = getenv("QUAKE_PALETTE"))) {
  219.         if ((palFile = __open(palName, H_READ_BINARY)) < 0) {
  220.           eprintf("no palette available\n");
  221.           tfree(Palette);
  222.           return 0;
  223.         }
  224.         else
  225.           closepal = TRUE;
  226.       }
  227.       else {
  228.         eprintf("no palette available\n");
  229.         tfree(Palette);
  230.         return 0;
  231.       }
  232.     }
  233.     else
  234.       closepal = TRUE;
  235.       }
  236.  
  237.       __read(palFile, Palette, 256 * 3);
  238.  
  239.       if (closepal)
  240.     __close(palFile);
  241.       else
  242.     __lseek(palFile, 0, SEEK_SET);
  243.  
  244.       /*
  245.        * small trick
  246.        */
  247.       cachedPalette = Palette;
  248.       Palette = GetPalette();
  249.     }
  250.     else
  251.       __memcpy(Palette, cachedPalette, 256 * 3);
  252.   }
  253.  
  254.   if (darkness)
  255.     Palette = GetDarkness(Palette);
  256.  
  257.   return Palette;
  258. }
  259.  
  260. /*
  261.  * Lumps
  262.  */
  263. struct palpic *GetLMP(register HANDLE file, register char *lmpName)
  264. {
  265.   struct lump Lump;
  266.   struct palpic *Picture;
  267.  
  268.   __read(file, &Lump, sizeof(struct lump));
  269.  
  270.   if ((Picture = pmalloc(LittleLong(Lump.width), LittleLong(Lump.height), 0, lmpName)))
  271.     __read(file, Picture->rawdata, Picture->width * Picture->height);
  272.  
  273.   return Picture;
  274. }
  275.  
  276. struct palpic *ParseLMP(register struct lump *Lump, register char *lmpName)
  277. {
  278.   struct palpic *Picture;
  279.  
  280.   if ((Picture = pmalloc(LittleLong(Lump->width), LittleLong(Lump->height), 0, lmpName)))
  281.     __memcpy(Picture->rawdata, Lump->rawdata, Picture->width * Picture->height);
  282.  
  283.   return Picture;
  284. }
  285.  
  286. bool PutLMP(register HANDLE file, register struct palpic * Picture)
  287. {
  288.   struct lump Lump;
  289.   int size = sizeof(struct lump) + (Picture->width * Picture->height);
  290.  
  291.   Lump.width = LittleLong(Picture->width);
  292.   Lump.height = LittleLong(Picture->height);
  293.   __write(file, &Lump, 2 * sizeof(int));
  294.  
  295.   if (__write(file, Picture->rawdata, size) != size)
  296.     return FALSE;
  297.   else
  298.     return TRUE;
  299. }
  300.  
  301. bool PasteLMP(register struct lump * Lump, register struct palpic * Picture)
  302. {
  303.   Lump->width = LittleLong(Picture->width);
  304.   Lump->height = LittleLong(Picture->height);
  305.   __memcpy(((char *)Lump) + sizeof(struct lump), Picture->rawdata, (Picture->width * Picture->height));
  306.  
  307.   return TRUE;
  308. }
  309.  
  310. /*
  311.  * compressed
  312.  */
  313.  
  314. char Compression = CMP_NONE;
  315.  
  316. char *GetLZ77(register HANDLE file, register int readsize)
  317. {
  318.   char *inData, *outData = 0;
  319.  
  320.   if (!readsize) {
  321.     int oldoffset = __ltell(file);
  322.  
  323.     __lseek(file, 0, SEEK_END);
  324.     readsize = __ltell(file);
  325.     __lseek(file, oldoffset, SEEK_SET);
  326.   }
  327.  
  328.   if ((inData = (char *)tmalloc(readsize))) {
  329.     int size;
  330.  
  331.     __read(file, inData, readsize);
  332.     if ((size = LZWSSize(inData)) > ERROR) {
  333.       mprintf("prepare to decrunch %d bytes ... \n", size);
  334.       if ((outData = (char *)tmalloc(size))) {
  335.     if (LZWSDecrunch(size, inData, outData) < ERROR) {
  336.       eprintf("failed to decrunch\n");
  337.       tfree(outData);
  338.       outData = 0;
  339.     }
  340.       }
  341.       else
  342.     eprintf(failed_memory, size, "decrunch");
  343.     }
  344.     tfree(inData);
  345.   }
  346.   else
  347.     eprintf(failed_memory, readsize, "read crunched");
  348.  
  349.   return outData;
  350. }
  351.  
  352. char *ParseLZ77(register char *inData, register int readsize)
  353. {
  354.   char *outData = 0;
  355.  
  356.   if (readsize > 0) {
  357.     int size;
  358.  
  359.     if ((size = LZWSSize(inData)) > ERROR) {
  360.       mprintf("prepare to decrunch %d bytes ... \n", size);
  361.       if ((outData = (char *)tmalloc(size))) {
  362.     if (LZWSDecrunch(size, inData, outData) < ERROR) {
  363.       eprintf("failed to decrunch\n");
  364.       tfree(outData);
  365.       outData = 0;
  366.     }
  367.       }
  368.       else
  369.     eprintf(failed_memory, size, "decrunch");
  370.     }
  371.   }
  372.  
  373.   return outData;
  374. }
  375.  
  376. int PutLZ77(register HANDLE file, register char *inData, register int size)
  377. {
  378.   char *outData, *saveData;
  379.   int retval = -1;
  380.  
  381.   if ((outData = (char *)tmalloc(size))) {
  382.     if ((retval = LZWSCrunch(size, size, size * 2, inData, outData)) > ERROR) {
  383.       mprintf("crunched %d to %d (%d%%)\n", size, retval, ((retval * 100) / size));
  384.       if (__write(file, outData, retval) != retval)
  385.     retval = -1;
  386.  
  387.       if ((saveData = (char *)tmalloc(size))) {
  388.     int error, byte;
  389.  
  390.     if ((error = LZWSDecrunch(size, outData, saveData)) > ERROR) {
  391.       for (byte = 0; byte < size; byte++) {
  392.         if (inData[byte] != saveData[byte])
  393.           break;
  394.       }
  395.       if (byte != size)
  396.         eprintf("difference at %d\n", byte);
  397.     }
  398.     tfree(saveData);
  399.       }
  400.     }
  401.     tfree(outData);
  402.   }
  403.   else
  404.     eprintf(failed_memory, size, "write crunched");
  405.  
  406.   return retval;
  407. }
  408.  
  409. int PasteLZ77(register char *outData, register char *inData, register int size)
  410. {
  411.   return LZWSCrunch(size, size, size * 2, inData, outData);
  412. }
  413.  
  414. /*
  415.  * Unknown/Raw
  416.  */
  417. struct rawdata *GetRaw(register HANDLE file, register char *rawName, register int size)
  418. {
  419.   struct rawdata *rawData = 0;
  420.  
  421.   if (!size) {
  422.     int oldoffset = __ltell(file);
  423.  
  424.     __lseek(file, 0, SEEK_END);
  425.     size = __ltell(file);
  426.     __lseek(file, oldoffset, SEEK_SET);
  427.   }
  428.  
  429.   if ((rawData = rmalloc(size + 1, rawName))) {
  430.     __read(file, rawData->rawdata, size);
  431.     rawData->size--;
  432.   }
  433.  
  434.   return rawData;
  435. }
  436.  
  437. struct rawdata *ParseRaw(register char *mem, register char *rawName, register int size)
  438. {
  439.   struct rawdata *rawData = 0;
  440.  
  441.   if (size)
  442.     if ((rawData = rmalloc(size + 1, rawName))) {
  443.       __memcpy(rawData->rawdata, mem, size);
  444.       rawData->size--;
  445.     }
  446.  
  447.   return rawData;
  448. }
  449.  
  450. bool PutRaw(register HANDLE file, register struct rawdata * rawData)
  451. {
  452.   if (__write(file, rawData->rawdata, rawData->size) != rawData->size)
  453.     return FALSE;
  454.   else
  455.     return TRUE;
  456. }
  457.  
  458. bool PasteRaw(register char *mem, register struct rawdata * rawData)
  459. {
  460.   __memcpy(mem, rawData->rawdata, rawData->size);
  461.   return TRUE;
  462. }
  463.